home *** CD-ROM | disk | FTP | other *** search
/ Micromanía 92 / CDMM92_1.ISO / SOF 2 SDK / sof2sdk-101.msi / _92D6AC311BB48EBA344BBABC89DA6AB0 / _DECBCD37C9A84C2BA0F2EBC2CD23D810 < prev    next >
Encoding:
Text File  |  2002-06-19  |  33.2 KB  |  1,109 lines
  1. // Copyright (C) 2001-2002 Raven Software.
  2. //
  3. #include "g_local.h"
  4. #include "bg_public.h"
  5.  
  6. // this file is only included when building a dll
  7. // g_syscalls.asm is included instead when building a qvm
  8.  
  9. static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1;
  10.  
  11.  
  12. void dllEntry( int (QDECL *syscallptr)( int arg,... ) ) {
  13.     syscall = syscallptr;
  14. }
  15.  
  16. int PASSFLOAT( float x ) {
  17.     float    floatTemp;
  18.     floatTemp = x;
  19.     return *(int *)&floatTemp;
  20. }
  21.  
  22. void    trap_Printf( const char *fmt ) {
  23.     syscall( G_PRINT, fmt );
  24. }
  25.  
  26. void    trap_Error( const char *fmt ) {
  27.     syscall( G_ERROR, fmt );
  28. }
  29.  
  30. int        trap_Milliseconds( void ) {
  31.     return syscall( G_MILLISECONDS ); 
  32. }
  33. int        trap_Argc( void ) {
  34.     return syscall( G_ARGC );
  35. }
  36.  
  37. void    trap_Argv( int n, char *buffer, int bufferLength ) {
  38.     syscall( G_ARGV, n, buffer, bufferLength );
  39. }
  40.  
  41. int        trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
  42.     return syscall( G_FS_FOPEN_FILE, qpath, f, mode );
  43. }
  44.  
  45. void    trap_FS_Read( void *buffer, int len, fileHandle_t f ) {
  46.     syscall( G_FS_READ, buffer, len, f );
  47. }
  48.  
  49. void    trap_FS_Write( const void *buffer, int len, fileHandle_t f ) {
  50.     syscall( G_FS_WRITE, buffer, len, f );
  51. }
  52.  
  53. void    trap_FS_FCloseFile( fileHandle_t f ) {
  54.     syscall( G_FS_FCLOSE_FILE, f );
  55. }
  56.  
  57. int trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
  58.     return syscall( G_FS_GETFILELIST, path, extension, listbuf, bufsize );
  59. }
  60.  
  61. void    trap_SendConsoleCommand( int exec_when, const char *text ) {
  62.     syscall( G_SEND_CONSOLE_COMMAND, exec_when, text );
  63. }
  64.  
  65. void    trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags, float MinValue, float MaxValue ) {
  66.     syscall( G_CVAR_REGISTER, cvar, var_name, value, flags, PASSFLOAT(MinValue), PASSFLOAT(MaxValue) );
  67. }
  68.  
  69. void    trap_Cvar_Update( vmCvar_t *cvar ) {
  70.     syscall( G_CVAR_UPDATE, cvar );
  71. }
  72.  
  73. void trap_Cvar_Set( const char *var_name, const char *value ) {
  74.     syscall( G_CVAR_SET, var_name, value );
  75. }
  76.  
  77. int trap_Cvar_VariableIntegerValue( const char *var_name ) {
  78.     return syscall( G_CVAR_VARIABLE_INTEGER_VALUE, var_name );
  79. }
  80.  
  81. void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
  82.     syscall( G_CVAR_VARIABLE_STRING_BUFFER, var_name, buffer, bufsize );
  83. }
  84.  
  85.  
  86. void trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t,
  87.                          playerState_t *clients, int sizeofGClient ) {
  88.     syscall( G_LOCATE_GAME_DATA, gEnts, numGEntities, sizeofGEntity_t, clients, sizeofGClient );
  89. }
  90.  
  91. void trap_RMG_Init(int terrainID)
  92. {
  93.     syscall(G_RMG_INIT, terrainID);
  94. }
  95.  
  96. void trap_DropClient( int clientNum, const char *reason ) {
  97.     syscall( G_DROP_CLIENT, clientNum, reason );
  98. }
  99.  
  100. void trap_SendServerCommand( int clientNum, const char *text ) {
  101.     syscall( G_SEND_SERVER_COMMAND, clientNum, text );
  102. }
  103.  
  104. void trap_SetConfigstring( int num, const char *string ) {
  105.     syscall( G_SET_CONFIGSTRING, num, string );
  106. }
  107.  
  108. void trap_GetConfigstring( int num, char *buffer, int bufferSize ) {
  109.     syscall( G_GET_CONFIGSTRING, num, buffer, bufferSize );
  110. }
  111.  
  112. void trap_GetUserinfo( int num, char *buffer, int bufferSize ) {
  113.     syscall( G_GET_USERINFO, num, buffer, bufferSize );
  114. }
  115.  
  116. void trap_SetUserinfo( int num, const char *buffer ) {
  117.     syscall( G_SET_USERINFO, num, buffer );
  118. }
  119.  
  120. void trap_GetServerinfo( char *buffer, int bufferSize ) {
  121.     syscall( G_GET_SERVERINFO, buffer, bufferSize );
  122. }
  123.  
  124. void trap_SetBrushModel( gentity_t *ent, const char *name ) {
  125.     syscall( G_SET_BRUSH_MODEL, ent, name );
  126. }
  127.  
  128. void trap_SetActiveSubBSP(int index)
  129. {
  130.     syscall( G_SET_ACTIVE_SUBBSP, index );
  131. }
  132.  
  133. void trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) {
  134.     syscall( G_TRACE, results, start, mins, maxs, end, passEntityNum, contentmask, 0, 10 );
  135. }
  136.  
  137. void trap_TraceCapsule( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) {
  138.     syscall( G_TRACECAPSULE, results, start, mins, maxs, end, passEntityNum, contentmask, 0, 10 );
  139. }
  140.  
  141. int trap_PointContents( const vec3_t point, int passEntityNum ) {
  142.     return syscall( G_POINT_CONTENTS, point, passEntityNum );
  143. }
  144.  
  145.  
  146. qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 ) {
  147.     return syscall( G_IN_PVS, p1, p2 );
  148. }
  149.  
  150. qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 ) {
  151.     return syscall( G_IN_PVS_IGNORE_PORTALS, p1, p2 );
  152. }
  153.  
  154. void trap_AdjustAreaPortalState( gentity_t *ent, qboolean open ) {
  155.     syscall( G_ADJUST_AREA_PORTAL_STATE, ent, open );
  156. }
  157.  
  158. qboolean trap_AreasConnected( int area1, int area2 ) {
  159.     return syscall( G_AREAS_CONNECTED, area1, area2 );
  160. }
  161.  
  162. void trap_LinkEntity( gentity_t *ent ) {
  163.     syscall( G_LINKENTITY, ent );
  164. }
  165.  
  166. void trap_UnlinkEntity( gentity_t *ent ) {
  167.     syscall( G_UNLINKENTITY, ent );
  168. }
  169.  
  170. int trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *list, int maxcount ) {
  171.     return syscall( G_ENTITIES_IN_BOX, mins, maxs, list, maxcount );
  172. }
  173.  
  174. qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) {
  175.     return syscall( G_ENTITY_CONTACT, mins, maxs, ent );
  176. }
  177.  
  178. qboolean trap_EntityContactCapsule( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) {
  179.     return syscall( G_ENTITY_CONTACTCAPSULE, mins, maxs, ent );
  180. }
  181.  
  182. int trap_BotAllocateClient( void ) {
  183.     return syscall( G_BOT_ALLOCATE_CLIENT );
  184. }
  185.  
  186. void trap_BotFreeClient( int clientNum ) {
  187.     syscall( G_BOT_FREE_CLIENT, clientNum );
  188. }
  189.  
  190. void trap_GetUsercmd( int clientNum, usercmd_t *cmd ) {
  191.     syscall( G_GET_USERCMD, clientNum, cmd );
  192. }
  193.  
  194. qboolean trap_GetEntityToken( char *buffer, int bufferSize ) {
  195.     return syscall( G_GET_ENTITY_TOKEN, buffer, bufferSize );
  196. }
  197.  
  198. void *trap_BotGetMemoryGame(int size)
  199. {
  200.     void *ptr;
  201.  
  202.     ptr = (void *)syscall( G_BOT_GET_MEMORY, size );
  203.  
  204.     return ptr;
  205. }
  206.  
  207. void trap_BotFreeMemoryGame(void *ptr)
  208. {
  209.     syscall( G_BOT_FREE_MEMORY, ptr);
  210. }
  211.  
  212. int trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points) {
  213.     return syscall( G_DEBUG_POLYGON_CREATE, color, numPoints, points );
  214. }
  215.  
  216. void trap_DebugPolygonDelete(int id) {
  217.     syscall( G_DEBUG_POLYGON_DELETE, id );
  218. }
  219.  
  220. int trap_RealTime( qtime_t *qtime ) {
  221.     return syscall( G_REAL_TIME, qtime );
  222. }
  223.  
  224. void trap_SnapVector( float *v ) {
  225.     syscall( G_SNAPVECTOR, v );
  226. }
  227.  
  228. // BotLib traps start here
  229. int trap_BotLibSetup( void ) {
  230.     return syscall( BOTLIB_SETUP );
  231. }
  232.  
  233. int trap_BotLibShutdown( void ) {
  234.     return syscall( BOTLIB_SHUTDOWN );
  235. }
  236.  
  237. int trap_BotLibVarSet(char *var_name, char *value) {
  238.     return syscall( BOTLIB_LIBVAR_SET, var_name, value );
  239. }
  240.  
  241. int trap_BotLibVarGet(char *var_name, char *value, int size) {
  242.     return syscall( BOTLIB_LIBVAR_GET, var_name, value, size );
  243. }
  244.  
  245. int trap_BotLibDefine(char *string) {
  246.     return syscall( BOTLIB_PC_ADD_GLOBAL_DEFINE, string );
  247. }
  248.  
  249. int trap_BotLibStartFrame(float time) {
  250.     return syscall( BOTLIB_START_FRAME, PASSFLOAT( time ) );
  251. }
  252.  
  253. int trap_BotLibLoadMap(const char *mapname) {
  254.     return syscall( BOTLIB_LOAD_MAP, mapname );
  255. }
  256.  
  257. int trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue) {
  258.     return syscall( BOTLIB_UPDATENTITY, ent, bue );
  259. }
  260.  
  261. int trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3) {
  262.     return syscall( BOTLIB_TEST, parm0, parm1, parm2, parm3 );
  263. }
  264.  
  265. int trap_BotGetSnapshotEntity( int clientNum, int sequence ) {
  266.     return syscall( BOTLIB_GET_SNAPSHOT_ENTITY, clientNum, sequence );
  267. }
  268.  
  269. int trap_BotGetServerCommand(int clientNum, char *message, int size) {
  270.     return syscall( BOTLIB_GET_CONSOLE_MESSAGE, clientNum, message, size );
  271. }
  272.  
  273. void trap_BotUserCommand(int clientNum, usercmd_t *ucmd) {
  274.     syscall( BOTLIB_USER_COMMAND, clientNum, ucmd );
  275. }
  276.  
  277. void trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info) {
  278.     syscall( BOTLIB_AAS_ENTITY_INFO, entnum, info );
  279. }
  280.  
  281. int trap_AAS_Initialized(void) {
  282.     return syscall( BOTLIB_AAS_INITIALIZED );
  283. }
  284.  
  285. void trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs) {
  286.     syscall( BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX, presencetype, mins, maxs );
  287. }
  288.  
  289. float trap_AAS_Time(void) {
  290.     int temp;
  291.     temp = syscall( BOTLIB_AAS_TIME );
  292.     return (*(float*)&temp);
  293. }
  294.  
  295. int trap_AAS_PointAreaNum(vec3_t point) {
  296.     return syscall( BOTLIB_AAS_POINT_AREA_NUM, point );
  297. }
  298.  
  299. int trap_AAS_PointReachabilityAreaIndex(vec3_t point) {
  300.     return syscall( BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX, point );
  301. }
  302.  
  303. int trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas) {
  304.     return syscall( BOTLIB_AAS_TRACE_AREAS, start, end, areas, points, maxareas );
  305. }
  306.  
  307. int trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas) {
  308.     return syscall( BOTLIB_AAS_BBOX_AREAS, absmins, absmaxs, areas, maxareas );
  309. }
  310.  
  311. int trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info ) {
  312.     return syscall( BOTLIB_AAS_AREA_INFO, areanum, info );
  313. }
  314.  
  315. int trap_AAS_PointContents(vec3_t point) {
  316.     return syscall( BOTLIB_AAS_POINT_CONTENTS, point );
  317. }
  318.  
  319. int trap_AAS_NextBSPEntity(int ent) {
  320.     return syscall( BOTLIB_AAS_NEXT_BSP_ENTITY, ent );
  321. }
  322.  
  323. int trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size) {
  324.     return syscall( BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY, ent, key, value, size );
  325. }
  326.  
  327. int trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v) {
  328.     return syscall( BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY, ent, key, v );
  329. }
  330.  
  331. int trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value) {
  332.     return syscall( BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY, ent, key, value );
  333. }
  334.  
  335. int trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value) {
  336.     return syscall( BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY, ent, key, value );
  337. }
  338.  
  339. int trap_AAS_AreaReachability(int areanum) {
  340.     return syscall( BOTLIB_AAS_AREA_REACHABILITY, areanum );
  341. }
  342.  
  343. int trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags) {
  344.     return syscall( BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA, areanum, origin, goalareanum, travelflags );
  345. }
  346.  
  347. int trap_AAS_EnableRoutingArea( int areanum, int enable ) {
  348.     return syscall( BOTLIB_AAS_ENABLE_ROUTING_AREA, areanum, enable );
  349. }
  350.  
  351. int trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin,
  352.                             int goalareanum, int travelflags, int maxareas, int maxtime,
  353.                             int stopevent, int stopcontents, int stoptfl, int stopareanum) {
  354.     return syscall( BOTLIB_AAS_PREDICT_ROUTE, route, areanum, origin, goalareanum, travelflags, maxareas, maxtime, stopevent, stopcontents, stoptfl, stopareanum );
  355. }
  356.  
  357. int trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
  358.                                         void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals,
  359.                                         int type) {
  360.     return syscall( BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL, start, startareanum, goal, goalareanum, travelflags, altroutegoals, maxaltroutegoals, type );
  361. }
  362.  
  363. int trap_AAS_Swimming(vec3_t origin) {
  364.     return syscall( BOTLIB_AAS_SWIMMING, origin );
  365. }
  366.  
  367. int trap_AAS_PredictClientMovement(void /* struct aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize) {
  368.     return syscall( BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT, move, entnum, origin, presencetype, onground, velocity, cmdmove, cmdframes, maxframes, PASSFLOAT(frametime), stopevent, stopareanum, visualize );
  369. }
  370.  
  371. void trap_EA_Say(int client, char *str) {
  372.     syscall( BOTLIB_EA_SAY, client, str );
  373. }
  374.  
  375. void trap_EA_SayTeam(int client, char *str) {
  376.     syscall( BOTLIB_EA_SAY_TEAM, client, str );
  377. }
  378.  
  379. void trap_EA_Command(int client, char *command) {
  380.     syscall( BOTLIB_EA_COMMAND, client, command );
  381. }
  382.  
  383. void trap_EA_Action(int client, int action) {
  384.     syscall( BOTLIB_EA_ACTION, client, action );
  385. }
  386.  
  387. void trap_EA_Gesture(int client) {
  388.     syscall( BOTLIB_EA_GESTURE, client );
  389. }
  390.  
  391. void trap_EA_Talk(int client) {
  392.     syscall( BOTLIB_EA_TALK, client );
  393. }
  394.  
  395. void trap_EA_Attack(int client) {
  396.     syscall( BOTLIB_EA_ATTACK, client );
  397. }
  398.  
  399. void trap_EA_Alt_Attack(int client) {
  400.     syscall( BOTLIB_EA_ALT_ATTACK, client );
  401. }
  402.  
  403. void trap_EA_ForcePower(int client) {
  404.     syscall( BOTLIB_EA_FORCEPOWER, client );
  405. }
  406.  
  407. void trap_EA_Use(int client) {
  408.     syscall( BOTLIB_EA_USE, client );
  409. }
  410.  
  411. void trap_EA_Respawn(int client) {
  412.     syscall( BOTLIB_EA_RESPAWN, client );
  413. }
  414.  
  415. void trap_EA_Crouch(int client) {
  416.     syscall( BOTLIB_EA_CROUCH, client );
  417. }
  418.  
  419. void trap_EA_MoveUp(int client) {
  420.     syscall( BOTLIB_EA_MOVE_UP, client );
  421. }
  422.  
  423. void trap_EA_MoveDown(int client) {
  424.     syscall( BOTLIB_EA_MOVE_DOWN, client );
  425. }
  426.  
  427. void trap_EA_MoveForward(int client) {
  428.     syscall( BOTLIB_EA_MOVE_FORWARD, client );
  429. }
  430.  
  431. void trap_EA_MoveBack(int client) {
  432.     syscall( BOTLIB_EA_MOVE_BACK, client );
  433. }
  434.  
  435. void trap_EA_MoveLeft(int client) {
  436.     syscall( BOTLIB_EA_MOVE_LEFT, client );
  437. }
  438.  
  439. void trap_EA_MoveRight(int client) {
  440.     syscall( BOTLIB_EA_MOVE_RIGHT, client );
  441. }
  442.  
  443. void trap_EA_SelectWeapon(int client, int weapon) {
  444.     syscall( BOTLIB_EA_SELECT_WEAPON, client, weapon );
  445. }
  446.  
  447. void trap_EA_Jump(int client) {
  448.     syscall( BOTLIB_EA_JUMP, client );
  449. }
  450.  
  451. void trap_EA_DelayedJump(int client) {
  452.     syscall( BOTLIB_EA_DELAYED_JUMP, client );
  453. }
  454.  
  455. void trap_EA_Move(int client, vec3_t dir, float speed) {
  456.     syscall( BOTLIB_EA_MOVE, client, dir, PASSFLOAT(speed) );
  457. }
  458.  
  459. void trap_EA_View(int client, vec3_t viewangles) {
  460.     syscall( BOTLIB_EA_VIEW, client, viewangles );
  461. }
  462.  
  463. void trap_EA_EndRegular(int client, float thinktime) {
  464.     syscall( BOTLIB_EA_END_REGULAR, client, PASSFLOAT(thinktime) );
  465. }
  466.  
  467. void trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input) {
  468.     syscall( BOTLIB_EA_GET_INPUT, client, PASSFLOAT(thinktime), input );
  469. }
  470.  
  471. void trap_EA_ResetInput(int client) {
  472.     syscall( BOTLIB_EA_RESET_INPUT, client );
  473. }
  474.  
  475. int trap_BotLoadCharacter(char *charfile, float skill) {
  476.     return syscall( BOTLIB_AI_LOAD_CHARACTER, charfile, PASSFLOAT(skill));
  477. }
  478.  
  479. void trap_BotFreeCharacter(int character) {
  480.     syscall( BOTLIB_AI_FREE_CHARACTER, character );
  481. }
  482.  
  483. float trap_Characteristic_Float(int character, int index) {
  484.     int temp;
  485.     temp = syscall( BOTLIB_AI_CHARACTERISTIC_FLOAT, character, index );
  486.     return (*(float*)&temp);
  487. }
  488.  
  489. float trap_Characteristic_BFloat(int character, int index, float min, float max) {
  490.     int temp;
  491.     temp = syscall( BOTLIB_AI_CHARACTERISTIC_BFLOAT, character, index, PASSFLOAT(min), PASSFLOAT(max) );
  492.     return (*(float*)&temp);
  493. }
  494.  
  495. int trap_Characteristic_Integer(int character, int index) {
  496.     return syscall( BOTLIB_AI_CHARACTERISTIC_INTEGER, character, index );
  497. }
  498.  
  499. int trap_Characteristic_BInteger(int character, int index, int min, int max) {
  500.     return syscall( BOTLIB_AI_CHARACTERISTIC_BINTEGER, character, index, min, max );
  501. }
  502.  
  503. void trap_Characteristic_String(int character, int index, char *buf, int size) {
  504.     syscall( BOTLIB_AI_CHARACTERISTIC_STRING, character, index, buf, size );
  505. }
  506.  
  507. int trap_BotAllocChatState(void) {
  508.     return syscall( BOTLIB_AI_ALLOC_CHAT_STATE );
  509. }
  510.  
  511. void trap_BotFreeChatState(int handle) {
  512.     syscall( BOTLIB_AI_FREE_CHAT_STATE, handle );
  513. }
  514.  
  515. void trap_BotQueueConsoleMessage(int chatstate, int type, char *message) {
  516.     syscall( BOTLIB_AI_QUEUE_CONSOLE_MESSAGE, chatstate, type, message );
  517. }
  518.  
  519. void trap_BotRemoveConsoleMessage(int chatstate, int handle) {
  520.     syscall( BOTLIB_AI_REMOVE_CONSOLE_MESSAGE, chatstate, handle );
  521. }
  522.  
  523. int trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm) {
  524.     return syscall( BOTLIB_AI_NEXT_CONSOLE_MESSAGE, chatstate, cm );
  525. }
  526.  
  527. int trap_BotNumConsoleMessages(int chatstate) {
  528.     return syscall( BOTLIB_AI_NUM_CONSOLE_MESSAGE, chatstate );
  529. }
  530.  
  531. void trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
  532.     syscall( BOTLIB_AI_INITIAL_CHAT, chatstate, type, mcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
  533. }
  534.  
  535. int    trap_BotNumInitialChats(int chatstate, char *type) {
  536.     return syscall( BOTLIB_AI_NUM_INITIAL_CHATS, chatstate, type );
  537. }
  538.  
  539. int trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
  540.     return syscall( BOTLIB_AI_REPLY_CHAT, chatstate, message, mcontext, vcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
  541. }
  542.  
  543. int trap_BotChatLength(int chatstate) {
  544.     return syscall( BOTLIB_AI_CHAT_LENGTH, chatstate );
  545. }
  546.  
  547. void trap_BotEnterChat(int chatstate, int client, int sendto) {
  548.     syscall( BOTLIB_AI_ENTER_CHAT, chatstate, client, sendto );
  549. }
  550.  
  551. void trap_BotGetChatMessage(int chatstate, char *buf, int size) {
  552.     syscall( BOTLIB_AI_GET_CHAT_MESSAGE, chatstate, buf, size);
  553. }
  554.  
  555. int trap_StringContains(char *str1, char *str2, int casesensitive) {
  556.     return syscall( BOTLIB_AI_STRING_CONTAINS, str1, str2, casesensitive );
  557. }
  558.  
  559. int trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context) {
  560.     return syscall( BOTLIB_AI_FIND_MATCH, str, match, context );
  561. }
  562.  
  563. void trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size) {
  564.     syscall( BOTLIB_AI_MATCH_VARIABLE, match, variable, buf, size );
  565. }
  566.  
  567. void trap_UnifyWhiteSpaces(char *string) {
  568.     syscall( BOTLIB_AI_UNIFY_WHITE_SPACES, string );
  569. }
  570.  
  571. void trap_BotReplaceSynonyms(char *string, unsigned long int context) {
  572.     syscall( BOTLIB_AI_REPLACE_SYNONYMS, string, context );
  573. }
  574.  
  575. int trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname) {
  576.     return syscall( BOTLIB_AI_LOAD_CHAT_FILE, chatstate, chatfile, chatname );
  577. }
  578.  
  579. void trap_BotSetChatGender(int chatstate, int gender) {
  580.     syscall( BOTLIB_AI_SET_CHAT_GENDER, chatstate, gender );
  581. }
  582.  
  583. void trap_BotSetChatName(int chatstate, char *name, int client) {
  584.     syscall( BOTLIB_AI_SET_CHAT_NAME, chatstate, name, client );
  585. }
  586.  
  587. void trap_BotResetGoalState(int goalstate) {
  588.     syscall( BOTLIB_AI_RESET_GOAL_STATE, goalstate );
  589. }
  590.  
  591. void trap_BotResetAvoidGoals(int goalstate) {
  592.     syscall( BOTLIB_AI_RESET_AVOID_GOALS, goalstate );
  593. }
  594.  
  595. void trap_BotRemoveFromAvoidGoals(int goalstate, int number) {
  596.     syscall( BOTLIB_AI_REMOVE_FROM_AVOID_GOALS, goalstate, number);
  597. }
  598.  
  599. void trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
  600.     syscall( BOTLIB_AI_PUSH_GOAL, goalstate, goal );
  601. }
  602.  
  603. void trap_BotPopGoal(int goalstate) {
  604.     syscall( BOTLIB_AI_POP_GOAL, goalstate );
  605. }
  606.  
  607. void trap_BotEmptyGoalStack(int goalstate) {
  608.     syscall( BOTLIB_AI_EMPTY_GOAL_STACK, goalstate );
  609. }
  610.  
  611. void trap_BotDumpAvoidGoals(int goalstate) {
  612.     syscall( BOTLIB_AI_DUMP_AVOID_GOALS, goalstate );
  613. }
  614.  
  615. void trap_BotDumpGoalStack(int goalstate) {
  616.     syscall( BOTLIB_AI_DUMP_GOAL_STACK, goalstate );
  617. }
  618.  
  619. void trap_BotGoalName(int number, char *name, int size) {
  620.     syscall( BOTLIB_AI_GOAL_NAME, number, name, size );
  621. }
  622.  
  623. int trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
  624.     return syscall( BOTLIB_AI_GET_TOP_GOAL, goalstate, goal );
  625. }
  626.  
  627. int trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
  628.     return syscall( BOTLIB_AI_GET_SECOND_GOAL, goalstate, goal );
  629. }
  630.  
  631. int trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags) {
  632.     return syscall( BOTLIB_AI_CHOOSE_LTG_ITEM, goalstate, origin, inventory, travelflags );
  633. }
  634.  
  635. int trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime) {
  636.     return syscall( BOTLIB_AI_CHOOSE_NBG_ITEM, goalstate, origin, inventory, travelflags, ltg, PASSFLOAT(maxtime) );
  637. }
  638.  
  639. int trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal) {
  640.     return syscall( BOTLIB_AI_TOUCHING_GOAL, origin, goal );
  641. }
  642.  
  643. int trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal) {
  644.     return syscall( BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE, viewer, eye, viewangles, goal );
  645. }
  646.  
  647. int trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal) {
  648.     return syscall( BOTLIB_AI_GET_LEVEL_ITEM_GOAL, index, classname, goal );
  649. }
  650.  
  651. int trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal) {
  652.     return syscall( BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL, num, goal );
  653. }
  654.  
  655. int trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal) {
  656.     return syscall( BOTLIB_AI_GET_MAP_LOCATION_GOAL, name, goal );
  657. }
  658.  
  659. float trap_BotAvoidGoalTime(int goalstate, int number) {
  660.     int temp;
  661.     temp = syscall( BOTLIB_AI_AVOID_GOAL_TIME, goalstate, number );
  662.     return (*(float*)&temp);
  663. }
  664.  
  665. void trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime) {
  666.     syscall( BOTLIB_AI_SET_AVOID_GOAL_TIME, goalstate, number, PASSFLOAT(avoidtime));
  667. }
  668.  
  669. void trap_BotInitLevelItems(void) {
  670.     syscall( BOTLIB_AI_INIT_LEVEL_ITEMS );
  671. }
  672.  
  673. void trap_BotUpdateEntityItems(void) {
  674.     syscall( BOTLIB_AI_UPDATE_ENTITY_ITEMS );
  675. }
  676.  
  677. int trap_BotLoadItemWeights(int goalstate, char *filename) {
  678.     return syscall( BOTLIB_AI_LOAD_ITEM_WEIGHTS, goalstate, filename );
  679. }
  680.  
  681. void trap_BotFreeItemWeights(int goalstate) {
  682.     syscall( BOTLIB_AI_FREE_ITEM_WEIGHTS, goalstate );
  683. }
  684.  
  685. void trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child) {
  686.     syscall( BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC, parent1, parent2, child );
  687. }
  688.  
  689. void trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename) {
  690.     syscall( BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC, goalstate, filename );
  691. }
  692.  
  693. void trap_BotMutateGoalFuzzyLogic(int goalstate, float range) {
  694.     syscall( BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC, goalstate, range );
  695. }
  696.  
  697. int trap_BotAllocGoalState(int state) {
  698.     return syscall( BOTLIB_AI_ALLOC_GOAL_STATE, state );
  699. }
  700.  
  701. void trap_BotFreeGoalState(int handle) {
  702.     syscall( BOTLIB_AI_FREE_GOAL_STATE, handle );
  703. }
  704.  
  705. void trap_BotResetMoveState(int movestate) {
  706.     syscall( BOTLIB_AI_RESET_MOVE_STATE, movestate );
  707. }
  708.  
  709. void trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type) {
  710.     syscall( BOTLIB_AI_ADD_AVOID_SPOT, movestate, origin, PASSFLOAT(radius), type);
  711. }
  712.  
  713. void trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags) {
  714.     syscall( BOTLIB_AI_MOVE_TO_GOAL, result, movestate, goal, travelflags );
  715. }
  716.  
  717. int trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type) {
  718.     return syscall( BOTLIB_AI_MOVE_IN_DIRECTION, movestate, dir, PASSFLOAT(speed), type );
  719. }
  720.  
  721. void trap_BotResetAvoidReach(int movestate) {
  722.     syscall( BOTLIB_AI_RESET_AVOID_REACH, movestate );
  723. }
  724.  
  725. void trap_BotResetLastAvoidReach(int movestate) {
  726.     syscall( BOTLIB_AI_RESET_LAST_AVOID_REACH,movestate  );
  727. }
  728.  
  729. int trap_BotReachabilityArea(vec3_t origin, int testground) {
  730.     return syscall( BOTLIB_AI_REACHABILITY_AREA, origin, testground );
  731. }
  732.  
  733. int trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target) {
  734.     return syscall( BOTLIB_AI_MOVEMENT_VIEW_TARGET, movestate, goal, travelflags, PASSFLOAT(lookahead), target );
  735. }
  736.  
  737. int trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target) {
  738.     return syscall( BOTLIB_AI_PREDICT_VISIBLE_POSITION, origin, areanum, goal, travelflags, target );
  739. }
  740.  
  741. int trap_BotAllocMoveState(void) {
  742.     return syscall( BOTLIB_AI_ALLOC_MOVE_STATE );
  743. }
  744.  
  745. void trap_BotFreeMoveState(int handle) {
  746.     syscall( BOTLIB_AI_FREE_MOVE_STATE, handle );
  747. }
  748.  
  749. void trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove) {
  750.     syscall( BOTLIB_AI_INIT_MOVE_STATE, handle, initmove );
  751. }
  752.  
  753. int trap_BotChooseBestFightWeapon(int weaponstate, int *inventory) {
  754.     return syscall( BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON, weaponstate, inventory );
  755. }
  756.  
  757. void trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo) {
  758.     syscall( BOTLIB_AI_GET_WEAPON_INFO, weaponstate, weapon, weaponinfo );
  759. }
  760.  
  761. int trap_BotLoadWeaponWeights(int weaponstate, char *filename) {
  762.     return syscall( BOTLIB_AI_LOAD_WEAPON_WEIGHTS, weaponstate, filename );
  763. }
  764.  
  765. int trap_BotAllocWeaponState(void) {
  766.     return syscall( BOTLIB_AI_ALLOC_WEAPON_STATE );
  767. }
  768.  
  769. void trap_BotFreeWeaponState(int weaponstate) {
  770.     syscall( BOTLIB_AI_FREE_WEAPON_STATE, weaponstate );
  771. }
  772.  
  773. void trap_BotResetWeaponState(int weaponstate) {
  774.     syscall( BOTLIB_AI_RESET_WEAPON_STATE, weaponstate );
  775. }
  776.  
  777. int trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child) {
  778.     return syscall( BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION, numranks, ranks, parent1, parent2, child );
  779. }
  780.  
  781. int trap_PC_LoadSource( const char *filename ) {
  782.     return syscall( BOTLIB_PC_LOAD_SOURCE, filename );
  783. }
  784.  
  785. int trap_PC_FreeSource( int handle ) {
  786.     return syscall( BOTLIB_PC_FREE_SOURCE, handle );
  787. }
  788.  
  789. int trap_PC_ReadToken( int handle, pc_token_t *pc_token ) {
  790.     return syscall( BOTLIB_PC_READ_TOKEN, handle, pc_token );
  791. }
  792.  
  793. int trap_PC_SourceFileAndLine( int handle, char *filename, int *line ) {
  794.     return syscall( BOTLIB_PC_SOURCE_FILE_AND_LINE, handle, filename, line );
  795. }
  796.  
  797. int trap_PC_LoadGlobalDefines ( const char* filename )
  798. {
  799.     return syscall ( BOTLIB_PC_LOAD_GLOBAL_DEFINES, filename );
  800. }
  801.  
  802. void trap_PC_RemoveAllGlobalDefines ( void )
  803. {
  804.     syscall ( BOTLIB_PC_REMOVE_ALL_GLOBAL_DEFINES );
  805. }
  806.  
  807. // CG Specific API calls
  808. void trap_G2_ListModelSurfaces(void *ghlInfo)
  809. {
  810.     syscall( G_G2_LISTSURFACES, ghlInfo);
  811. }
  812.  
  813. void trap_G2_ListModelBones(void *ghlInfo, int frame)
  814. {
  815.     syscall( G_G2_LISTBONES, ghlInfo, frame);
  816. }
  817.  
  818. void trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList)
  819. {
  820.     syscall( G_G2_SETMODELS, ghoul2, modelList, skinList);
  821. }
  822.  
  823. qboolean trap_G2_HaveWeGhoul2Models(    void *ghoul2)
  824. {
  825.     return (qboolean)(syscall(G_G2_HAVEWEGHOULMODELS, ghoul2));
  826. }
  827.  
  828. int    trap_G2API_AddBolt(void *ghoul2, const int modelIndex, const char *boneName)
  829. {
  830.     return (int) (syscall(G_G2_ADDBOLT, ghoul2, modelIndex, boneName));
  831. }
  832.  
  833. void trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo)
  834. {
  835.     syscall(G_G2_SETBOLTINFO, ghoul2, modelIndex, boltInfo);
  836. }
  837.  
  838. qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
  839.                                 const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
  840. {
  841.     return (qboolean)(syscall(G_G2_GETBOLT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
  842. }
  843.  
  844. int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
  845.                           qhandle_t customShader, int modelFlags, int lodBias)
  846. {
  847.     return syscall(G_G2_INITGHOUL2MODEL, ghoul2Ptr, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias);
  848. }
  849.  
  850. void trap_G2API_CleanGhoul2Models ( void **ghoul2Ptr )
  851. {
  852.     syscall(G_G2_CLEANMODELS, ghoul2Ptr);
  853. }
  854.  
  855. void trap_G2API_CollisionDetect ( 
  856.     CollisionRecord_t *collRecMap, 
  857.     void* ghoul2, 
  858.     const vec3_t angles, 
  859.     const vec3_t position,
  860.     int frameNumber, 
  861.     int entNum, 
  862.     vec3_t rayStart, 
  863.     vec3_t rayEnd, 
  864.     vec3_t scale, 
  865.     int traceFlags, 
  866.     int useLod
  867.     )
  868. {
  869.     syscall ( G_G2_COLLISIONDETECT, collRecMap, ghoul2, angles, position, frameNumber, entNum, rayStart, rayEnd, scale, traceFlags, useLod );
  870. }
  871.  
  872. qhandle_t trap_G2API_RegisterSkin ( const char *skinName, int numPairs, const char *skinPairs)
  873. {
  874.     return syscall(G_G2_REGISTERSKIN, skinName, numPairs, skinPairs );
  875. }
  876.  
  877. qboolean trap_G2API_SetSkin ( void* ghoul2, int modelIndex, qhandle_t customSkin)
  878. {
  879.     return syscall(G_G2_SETSKIN, ghoul2, modelIndex, customSkin );
  880. }
  881.  
  882. qboolean trap_G2API_GetAnimFileNameIndex ( void* ghoul2, qhandle_t modelIndex, const char* filename )
  883. {
  884.     return syscall(G_G2_GETANIMFILENAMEINDEX, ghoul2, modelIndex, filename );
  885. }
  886.  
  887. qboolean trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
  888.                                 const int up, const int right, const int forward, qhandle_t *modelList,
  889.                                 int blendTime , int currentTime )
  890. {
  891.     return (syscall(G_G2_ANGLEOVERRIDE, ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime));
  892. }
  893.  
  894. qboolean trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
  895.                               const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
  896. {
  897.     return syscall(G_G2_PLAYANIM, ghoul2, modelIndex, boneName, startFrame, endFrame, flags, PASSFLOAT(animSpeed), currentTime, PASSFLOAT(setFrame), blendTime);
  898. }
  899.  
  900. char *trap_G2API_GetGLAName(void *ghoul2, int modelIndex)
  901. {
  902.     return (char *)syscall(G_G2_GETGLANAME, ghoul2, modelIndex);
  903. }
  904.  
  905. int trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex)
  906. {
  907.     return syscall(G_G2_COPYGHOUL2INSTANCE, g2From, g2To, modelIndex);
  908. }
  909.  
  910. int trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo)
  911. {
  912.     return syscall(G_G2_COPYSPECIFICGHOUL2MODEL, g2From, modelFrom, g2To, modelTo);
  913. }
  914.  
  915. void trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To)
  916. {
  917.     syscall(G_G2_DUPLICATEGHOUL2INSTANCE, g2From, g2To);
  918. }
  919.  
  920. qboolean trap_G2API_RemoveGhoul2Model(void **ghlInfo, int modelIndex)
  921. {
  922.     return syscall(G_G2_REMOVEGHOUL2MODEL, ghlInfo, modelIndex);
  923. }
  924.  
  925. /*
  926. Ghoul2 Insert End
  927. */
  928.  
  929. // CGenericParser2 (void *) routines
  930. TGenericParser2 trap_GP_Parse(char **dataPtr, qboolean cleanFirst, qboolean writeable)
  931. {
  932.     return (TGenericParser2)syscall(G_GP_PARSE, dataPtr, cleanFirst, writeable);
  933. }
  934.  
  935. TGenericParser2 trap_GP_ParseFile(char *fileName, qboolean cleanFirst, qboolean writeable)
  936. {
  937.     return (TGenericParser2)syscall(G_GP_PARSE_FILE, fileName, cleanFirst, writeable);
  938. }
  939.  
  940. void trap_GP_Clean(TGenericParser2 GP2)
  941. {
  942.     syscall(G_GP_CLEAN, GP2);
  943. }
  944.  
  945. void trap_GP_Delete(TGenericParser2 *GP2)
  946. {
  947.     syscall(G_GP_DELETE, GP2);
  948. }
  949.  
  950. TGPGroup trap_GP_GetBaseParseGroup(TGenericParser2 GP2)
  951. {
  952.     return (TGPGroup)syscall(G_GP_GET_BASE_PARSE_GROUP, GP2);
  953. }
  954.  
  955.  
  956. // CGPGroup (void *) routines
  957. qboolean trap_GPG_GetName(TGPGroup GPG, char *Value)
  958. {
  959.     return (qboolean)syscall(G_GPG_GET_NAME, GPG, Value);
  960. }
  961.  
  962. TGPGroup trap_GPG_GetNext(TGPGroup GPG)
  963. {
  964.     return (TGPGroup)syscall(G_GPG_GET_NEXT, GPG);
  965. }
  966.  
  967. TGPGroup trap_GPG_GetInOrderNext(TGPGroup GPG)
  968. {
  969.     return (TGPGroup)syscall(G_GPG_GET_INORDER_NEXT, GPG);
  970. }
  971.  
  972. TGPGroup trap_GPG_GetInOrderPrevious(TGPGroup GPG)
  973. {
  974.     return (TGPGroup)syscall(G_GPG_GET_INORDER_PREVIOUS, GPG);
  975. }
  976.  
  977. TGPGroup trap_GPG_GetPairs(TGPGroup GPG)
  978. {
  979.     return (TGPGroup)syscall(G_GPG_GET_PAIRS, GPG);
  980. }
  981.  
  982. TGPGroup trap_GPG_GetInOrderPairs(TGPGroup GPG)
  983. {
  984.     return (TGPGroup)syscall(G_GPG_GET_INORDER_PAIRS, GPG);
  985. }
  986.  
  987. TGPGroup trap_GPG_GetSubGroups(TGPGroup GPG)
  988. {
  989.     return (TGPGroup)syscall(G_GPG_GET_SUBGROUPS, GPG);
  990. }
  991.  
  992. TGPGroup trap_GPG_GetInOrderSubGroups(TGPGroup GPG)
  993. {
  994.     return (TGPGroup)syscall(G_GPG_GET_INORDER_SUBGROUPS, GPG);
  995. }
  996.  
  997. TGPValue trap_GPG_FindSubGroup(TGPGroup GPG, const char *name)
  998. {
  999.     return (TGPValue)syscall(G_GPG_FIND_SUBGROUP, GPG, name);
  1000. }
  1001.  
  1002. TGPValue trap_GPG_FindPair(TGPGroup GPG, const char *key)
  1003. {
  1004.     return (TGPValue)syscall(G_GPG_FIND_PAIR, GPG, key);
  1005. }
  1006.  
  1007. qboolean trap_GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal, char *Value)
  1008. {
  1009.     return (qboolean)syscall(G_GPG_FIND_PAIRVALUE, GPG, key, defaultVal, Value);
  1010. }
  1011.  
  1012.  
  1013. // CGPValue (void *) routines
  1014. qboolean trap_GPV_GetName(TGPValue GPV, char *Value)
  1015. {
  1016.     return (qboolean)syscall(G_GPV_GET_NAME, GPV, Value);
  1017. }
  1018.  
  1019. TGPValue trap_GPV_GetNext(TGPValue GPV)
  1020. {
  1021.     return (TGPValue)syscall(G_GPV_GET_NEXT, GPV);
  1022. }
  1023.  
  1024. TGPValue trap_GPV_GetInOrderNext(TGPValue GPV)
  1025. {
  1026.     return (TGPValue)syscall(G_GPV_GET_INORDER_NEXT, GPV);
  1027. }
  1028.  
  1029. TGPValue trap_GPV_GetInOrderPrevious(TGPValue GPV)
  1030. {
  1031.     return (TGPValue)syscall(G_GPV_GET_INORDER_PREVIOUS, GPV);
  1032. }
  1033.  
  1034. qboolean trap_GPV_IsList(TGPValue GPV)
  1035. {
  1036.     return (qboolean)syscall(G_GPV_IS_LIST, GPV);
  1037. }
  1038.  
  1039. qboolean trap_GPV_GetTopValue(TGPValue GPV, char *Value)
  1040. {
  1041.     return (qboolean)syscall(G_GPV_GET_TOP_VALUE, GPV, Value);
  1042. }
  1043.  
  1044. TGPValue trap_GPV_GetList(TGPValue GPV)
  1045. {
  1046.     return (TGPValue)syscall(G_GPV_GET_LIST, GPV);
  1047. }
  1048.  
  1049. int    trap_CM_RegisterTerrain(const char *config)
  1050. {
  1051.     return syscall(G_CM_REGISTER_TERRAIN, config);
  1052. }
  1053.  
  1054. void trap_GetModelFormalName ( const char* model, const char* skin, char* name, int size )
  1055. {
  1056.     syscall ( G_GET_MODEL_FORMALNAME, model, skin, name, size );
  1057. }
  1058.  
  1059. void trap_GetWorldBounds ( vec3_t mins, vec3_t maxs )
  1060. {
  1061.     syscall ( G_GET_WORLD_BOUNDS, mins, maxs );
  1062. }
  1063.  
  1064. void *trap_VM_LocalAlloc ( int size )
  1065. {
  1066.     return (void *)syscall ( G_VM_LOCALALLOC, size );
  1067. }
  1068.  
  1069. void *trap_VM_LocalAllocUnaligned ( int size )
  1070. {
  1071.     return (void *)syscall ( G_VM_LOCALALLOCUNALIGNED, size );
  1072. }
  1073.  
  1074. void *trap_VM_LocalTempAlloc( int size )
  1075. {
  1076.     return (void *)syscall ( G_VM_LOCALTEMPALLOC, size );
  1077. }
  1078.  
  1079. void trap_VM_LocalTempFree( int size )
  1080. {
  1081.     syscall ( G_VM_LOCALTEMPFREE, size );
  1082. }
  1083.  
  1084. const char *trap_VM_LocalStringAlloc ( const char *source )
  1085. {
  1086.     return (const char *)syscall ( G_VM_LOCALSTRINGALLOC, source );
  1087. }
  1088.  
  1089. void trap_GT_Init ( const char* gametype, qboolean restart )
  1090. {
  1091.     syscall ( G_GT_INIT, gametype, restart );
  1092. }
  1093.  
  1094. void trap_GT_RunFrame ( int time )
  1095. {
  1096.     syscall ( G_GT_RUNFRAME, time );
  1097. }
  1098.  
  1099. void trap_GT_Start ( int time )
  1100. {
  1101.     syscall ( G_GT_START, time );
  1102. }
  1103.  
  1104. int trap_GT_SendEvent ( int event, int time, int arg0, int arg1, int arg2, int arg3, int arg4 )
  1105. {
  1106.     return syscall ( G_GT_SENDEVENT, event, time, arg0, arg1, arg2, arg3, arg4 );
  1107. }
  1108.  
  1109.